home *** CD-ROM | disk | FTP | other *** search
/ Young Minds / Young Minds Interactive CD-ROM.ISO / sdi / cursor.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-18  |  3.4 KB  |  127 lines
  1. /*****************************  cursor.c  ******************************/
  2. #include "sdi.h"
  3.  
  4. /*
  5.  * Copyright 1987 by Mark Weiser.
  6.  * Permission to reproduce and use in any manner whatsoever on Suns is granted
  7.  * so long as this copyright and other identifying marks of authorship
  8.  * in the code and the game remain intact and visible.  Use of this code
  9.  * in other products is reserved to me--I'm working on Mac and IBM versions.
  10.  */
  11.  
  12. /*
  13.  * Code to manage the dynamic cursor.
  14.  */
  15.  
  16. struct cursor *compute_cursor();
  17. struct pixrect *compute_cursor_image();
  18.  
  19. static short dynacursor_data[] = {
  20. #include "dynacursor.h"
  21. };
  22. mpr_static(dynabase_cursor_pr, 16, 16, 1, dynacursor_data);
  23.  
  24. static short cursor_data[] = {
  25. #include "cursor.h"
  26. };
  27. mpr_static(base_cursor_pr, 16, 16, 1, cursor_data);
  28.  
  29. struct cursor *
  30. init_cursor()
  31. {
  32.     static struct cursor *main_cursor = NULL;
  33.     extern int cursor_type;
  34.     if (main_cursor) {
  35.         cursor_destroy(main_cursor);
  36.     }
  37.     switch(cursor_type) {
  38.         case 0:
  39.             main_cursor = (struct cursor *)cursor_create(CURSOR_IMAGE, &base_cursor_pr,
  40.                 CURSOR_XHOT, 8, CURSOR_YHOT, 8,
  41.                 CURSOR_OP, PIX_SRC ^ PIX_DST,
  42.                 0);
  43.             break;
  44.         case 1:
  45.             main_cursor = (struct cursor *)cursor_create(CURSOR_OP, PIX_SRC ^ PIX_DST,
  46.                 CURSOR_IMAGE, &dynabase_cursor_pr,
  47.                 CURSOR_XHOT, 8, CURSOR_YHOT, 3,
  48.                 0);
  49.             break;
  50.         case 2:
  51.             main_cursor  = (struct cursor *)cursor_create(CURSOR_SHOW_CROSSHAIRS, TRUE,
  52.                 CURSOR_OP, PIX_SRC ^ PIX_DST,
  53.                 0);
  54.             break;
  55.         case 3:
  56.             main_cursor = (struct cursor *)cursor_create(CURSOR_SHOW_CROSSHAIRS, TRUE,
  57.                 CURSOR_OP, PIX_SRC ^ PIX_DST,
  58.                 CURSOR_IMAGE, &dynabase_cursor_pr,
  59.                 CURSOR_XHOT, 8, CURSOR_YHOT, 3,
  60.                 0);
  61.             break;
  62.         }
  63.     window_set(launchcanvas, WIN_CURSOR, main_cursor, 0);
  64.     window_set(citycanvas, WIN_CURSOR, main_cursor, 0);
  65. }
  66.  
  67. update_cursor()
  68. {
  69.     extern int cursor_type;
  70.     switch (cursor_type) {
  71.         case 1: case 3:
  72.             window_set(launchcanvas,
  73.                 WIN_CURSOR, compute_cursor(window_get(launchcanvas, WIN_CURSOR)),
  74.                 0);
  75.             window_set(citycanvas,
  76.                 WIN_CURSOR, compute_cursor(window_get(citycanvas, WIN_CURSOR)),
  77.                 0);
  78.             break;
  79.         default:
  80.             break;
  81.     }
  82. }
  83.  
  84. struct cursor *
  85. compute_cursor(c)
  86. struct cursor * c;
  87. {
  88.     cursor_set(c, 
  89.         CURSOR_IMAGE, compute_cursor_image(cursor_get(c, CURSOR_IMAGE)),
  90.         0);
  91.     return c;
  92. }
  93.  
  94. /* Returns a static structure, so get rid of it before reusing it. */
  95. struct pixrect *
  96. compute_cursor_image(pr)
  97. struct pixrect *pr;
  98. {
  99.     extern Panel_item rock_item;
  100.     int left_current = (int)panel_get_value(interceptor_item);
  101.     int left_max = (int)panel_get(interceptor_item, PANEL_MAX_VALUE);
  102.     int middle_current = (int)panel_get_value(rock_item);
  103.     int middle_max = (int)panel_get(rock_item, PANEL_MAX_VALUE);
  104.     int right_current = (int)panel_get_value(laser_item);
  105.     int right_max = (int)panel_get(laser_item, PANEL_MAX_VALUE);
  106.  
  107.     pr_rop(pr, 0, 0, 16, 16, PIX_SRC, &dynabase_cursor_pr, 0, 0);
  108.     put_line(pr, 1, 8, 15, left_current, left_max);
  109.     put_line(pr, 7, 8, 15, middle_current, middle_max);
  110.     put_line(pr, 13, 8, 15, right_current, right_max);
  111.     return pr;
  112. }
  113.  
  114. /*
  115.  * Draw a double-width line in pr from start to finish, with 
  116.  * length equal current/max. assumes finish > start.
  117.  */
  118. put_line(pr, x, start, finish, current, max)
  119. struct pixrect *pr;
  120. {
  121.     int length = (current*(finish-start+1))/max;
  122.     if (length == 0 && current != 0) length = 1;
  123.     pr_vector(pr, x, start-1, x, start+length-1, PIX_SRC, 1);
  124.     pr_vector(pr, x+1, start-1, x+1, start+length-1, PIX_SRC, 1);
  125.     pr_vector(pr, x+2, start-1, x+2, start+length-1, PIX_SRC, 1);
  126. }
  127.